package com.common.utils;


/**
 * @author xin.ding
 * @date 2019/12/12 9:40
 */
public class ArrayUtils {

    private ArrayUtils() {
        throw new UnsupportedOperationException();
    }

    /**
     * 判断字符串数组中是否包含某字符串（忽略大小写）
     */
    public static boolean containsNoCase(String[] array, String value) {
        return indexOfNoCase(array, value) > -1;
    }

    /**
     * 返回字符串在数组下标位置（忽略大小写）
     */
    public static int indexOfNoCase(String[] array, String value) {
        if (null != array) {
            for (int i = 0; i < array.length; i++) {
                if (value.equalsIgnoreCase(array[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 数组处理
     * 1.去空格
     * 2.转换为大写
     *
     * @param array 原数组
     * @return 处理后数组
     */
    public static String[] processArray(String[] array) {
        if (array != null) {
            for (int i = 0; i < array.length; i++) {
                array[i] = array[i].trim().toUpperCase();
            }
        }
        return array;
    }

    /**
     * 数组所有元素去空格处理
     *
     * @param array 原数组
     * @return 处理后数组
     */
    public static String[] trim(String[] array) {
        if (array != null) {
            for (int i = 0; i < array.length; i++) {
                array[i] = array[i].trim();
            }
        }
        return array;
    }

    /**
     * 两个数组合成一个数组
     *
     * @param array1 array1
     * @param array2 array2
     * @return array1+array2
     */
    public static String[] concat(String[] array1, String[] array2) {
        if (array1.length == 0) {
            return array2;
        }
        if (array2.length == 0) {
            return array1;
        }
        String[] resultArray = new String[array1.length + array2.length];
        System.arraycopy(array1, 0, resultArray, 0, array1.length);
        System.arraycopy(array2, 0, resultArray, array1.length, array2.length);
        return resultArray;
    }

    /**
     * 数组转换为字符串，数组元素之间按照指定字符分割
     *
     * @param array     数组
     * @param separator 分割字符
     * @return str
     */
    public static String join(final Object[] array, final String separator) {
        if (array == null) {
            return null;
        }
        return join(array, separator, 0, array.length);
    }

    /**
     * 数组转换为字符串，<b>指定数组元素<b/>之间按照指定字符分割
     *
     * @param array      数组
     * @param separator  分割字符
     * @param startIndex 分割起始位置
     * @param endIndex   分割结束位置
     * @return str
     */
    public static String join(final Object[] array, String separator, final int startIndex, final int endIndex) {
        if (array == null) {
            return null;
        }
        if (separator == null) {
            separator = "";
        }

        // endIndex - startIndex > 0:   Len = NofStrings *(len(firstString) + len(separator))
        //           (Assuming that all Strings are roughly equally long)
        final int noOfItems = endIndex - startIndex;
        if (noOfItems <= 0) {
            return "";
        }

        final StringBuilder buf = new StringBuilder(noOfItems);

        for (int i = startIndex; i < endIndex; i++) {
            if (i > startIndex) {
                buf.append(separator);
            }
            if (array[i] != null) {
                buf.append(array[i]);
            }
        }
        return buf.toString();
    }
}
